package com.wicket.okrapp.biz.service.nb;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.ObjectUtil;
import com.github.pagehelper.Page;
import com.wicket.okrapp.biz.service.dto.common.EvaObjTargetCycleDto;
import com.wicket.okrapp.biz.service.dto.common.EvaObjTargetCycleReportSortDto;
import com.wicket.okrapp.biz.service.dto.common.PicMultipleSetDataEntryDto;
import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.common.baseinfo.BaseInfoDO;
import com.wicket.okrapp.common.baseinfo.BaseInfoHolder;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrcomponent.common.annotations.BanAuto;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ： 手工接入方法
 * @since 2022/5/28 15:32
 *
 *
 * @version 1.0
 */
@Service
public class NbTask {

    /**
     * code:multiCollectionRemoveExistingData
     * name:M-汇报任务生成集合去除已存在数据（特殊方法）
     * desc:undefined
     **/
    @BanAuto
    @Trace(operationName = "M-汇报任务生成集合去除已存在数据（特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public GenerateCollectionRemoveExistingDataRespDto generateCollectionRemoveExistingData(GenerateCollectionRemoveExistingDataReqDto reqDto) {
        GenerateCollectionRemoveExistingDataRespDto retData = new GenerateCollectionRemoveExistingDataRespDto();
        if (CollUtil.isEmpty(reqDto.getVirtualOrgMemberList())) {
            return retData;
        }
        List<String> filteredList = new ArrayList<>(reqDto.getVirtualOrgMemberList());
        if(CollectionUtil.isNotEmpty(filteredList)){
            filteredList = filteredList.stream().distinct().collect(Collectors.toList());
        }

        if (CollUtil.isNotEmpty(reqDto.getLiableVirtualOrgMemberList())) {
            for (String one : reqDto.getLiableVirtualOrgMemberList()) {
                filteredList.remove(one);
            }
        }
        if (CollUtil.isNotEmpty(reqDto.getDirectorVirtualOrgMemberList())) {
            for (String one : reqDto.getDirectorVirtualOrgMemberList()) {
                filteredList.remove(one);
            }
        }
        retData.setVirtualOrgMemberList(filteredList);
        return retData;
    }

    /**
     * code:getLastFromDataList
     * name:M3-取排序列表中上一条数据（特殊方法）
     * desc:undefined
     **/
    @Trace(operationName = "M3-取排序列表中上一条数据（特殊方法）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public ObtainGetLastFromDataListRespDto obtainGetLastFromDataList(ObtainGetLastFromDataListReqDto reqDto) {
        ObtainGetLastFromDataListRespDto retData = new ObtainGetLastFromDataListRespDto();
        EvaObjTargetCycleReportSortDto lastData = new EvaObjTargetCycleReportSortDto();
        for(EvaObjTargetCycleReportSortDto oneData : reqDto.getEvaObjTargetCycleReportSortList()){
            if(oneData.getEvaObjTargetCycleId().equals(reqDto.getEvaObjTargetCycleId())){
                retData.setLastEvaObjTargetCycleId(lastData.getEvaObjTargetCycleId());
                break;
            }
            lastData = oneData;
        }
        return retData;
    }



    /**
     * code:timeEfficiencyCheck
     * name:M3-检查任务完成时间
     * desc:undefined
     **/
    @Trace(operationName = "M3-检查任务完成时间")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public CheckTimeScopeCheckRespDto checkTimeScopeCheck(CheckTimeScopeCheckReqDto reqDto) {
        CheckTimeScopeCheckRespDto retData = new CheckTimeScopeCheckRespDto();
        if(reqDto.getActualEndTime().getTime() < reqDto.getPlanEndTime().getTime()){
            retData.setTimeCompareResult("BEFORE");
        }else if(reqDto.getActualEndTime().getTime() > reqDto.getPlanEndTime().getTime()){
            retData.setTimeCompareResult("LATER");
        }else if(reqDto.getActualEndTime().getTime() == reqDto.getPlanEndTime().getTime()){
            retData.setTimeCompareResult("PRESENT");
        }
        return retData;
    }

    /**
     * code:caluTimeDiff
     * name:M3-计算时间差（开始时间）
     * desc:undefined
     **/
    @Trace(operationName = "M3-计算时间差（开始时间）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    public AddCaluDateDiffRespDto addCaluDateDiff(AddCaluDateDiffReqDto reqDto) {
        AddCaluDateDiffRespDto retData = new AddCaluDateDiffRespDto();
        int days = CommonFunctionHelper.differentDaysByString(reqDto.getCaluEndTime(),reqDto.getCaluStartTime());
        retData.setTimeDiffDays(String.valueOf(days));
        retData.setTimeDiff(String.valueOf(days*24));
        return retData;
    }




/**
      * code:objectToData
      * name:M执行图片单条转数据集
      * desc:undefined
      * gen by moon at 8/17/2022, 12:14:21 AM
      * 
      **/
     @Trace(operationName = "M执行图片单条转数据集")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementPicSingleSetDataEntryRespDto implementPicSingleSetDataEntry(ImplementPicSingleSetDataEntryReqDto reqDto) {
         ImplementPicSingleSetDataEntryRespDto retData = new ImplementPicSingleSetDataEntryRespDto();
         if(ObjectUtil.isEmpty(reqDto) || ObjectUtil.isEmpty(reqDto.getDatasetField())){
             return retData;
         }
         String[] fileList = reqDto.getDatasetField().split(",");
         if(ObjectUtil.isEmpty(fileList)){
             return retData;
         }
         List<String> retList = Arrays.asList(fileList);
         List<String> retNewList = new ArrayList<>();
         for(String one : retList){
             if(one.equals("--")){
                 continue;
             }
             retNewList.add(CommonFunctionHelper.getFilePath(one));
         }
         retData.setPicSingleSetDataEntryList(retNewList);
         return retData;
      }
/**
      * code:findLevelCode
      * name:M-查询找祖先列表（特殊方法）
      * desc:undefined
      * gen by moon at 8/28/2022, 4:07:04 PM
      * 
      **/
     @Trace(operationName = "M-查询找祖先列表（特殊方法）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public QueryLookAncestorNodeListRespDto queryLookAncestorNodeList(QueryLookAncestorNodeListReqDto reqDto) {
         QueryLookAncestorNodeListRespDto retData = new QueryLookAncestorNodeListRespDto();
         String oriCode = null;
         if(reqDto.getEvaObjTargetCycleCode()!=null && !reqDto.getEvaObjTargetCycleCode().isEmpty()){
             oriCode = reqDto.getEvaObjTargetCycleCode();
         }

         if(reqDto.getAssistNodeTypeObjectCode()!=null && !reqDto.getAssistNodeTypeObjectCode().isEmpty()){
             oriCode = reqDto.getAssistNodeTypeObjectCode();
         }

         if(reqDto.getComCode()!=null && !reqDto.getComCode().isEmpty()){
             oriCode = reqDto.getComCode();
         }

         if(oriCode==null || oriCode.isEmpty()){
             return retData;
         }
         int dealSize = 4;
         while(oriCode.length() >= dealSize){
             String oneCode = oriCode.substring(0,dealSize);
             if(oneCode!=null && !oneCode.isEmpty()){
                 EvaObjTargetCycleDto elm = new EvaObjTargetCycleDto();
                 elm.setEvaObjTargetCycleCode(oneCode);
                 retData.getEvaObjTargetCycleList().add(elm);
                 retData.getLookAncestorNodeList().add(oneCode);
             }
             dealSize = dealSize + 4;
         }
         retData.getLookAncestorNodeList().remove(oriCode);
         return retData;
      }
/**
      * code:getPublicFieldCache
      * name:M3-获取接收字段（特殊方法）
      * desc:undefined
      * gen by moon at 8/28/2022, 4:07:14 PM
      * 
      **/
     @Trace(operationName = "M3-获取接收字段（特殊方法）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ObtainReceiveFieldRespDto obtainReceiveField(ObtainReceiveFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto,ObtainReceiveFieldRespDto.class);
      }
/**
      * code:publicFieldCache
      * name:M3更新公共字段缓存
      * desc:undefined
      * gen by moon at 8/28/2022, 4:07:23 PM
      * 
      **/
     @Trace(operationName = "M3更新公共字段缓存")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public RefreshPublicFieldCacheRespDto refreshPublicFieldCache(RefreshPublicFieldCacheReqDto reqDto) {
         if(BaseInfoHolder.contextHolder.get()!=null){
             BaseInfoHolder.contextHolder.remove();
         }
         BaseInfoDO domain = new BaseInfoDO();
         domain.setSpecSpaceId(reqDto.getSpaceId());
         domain.setSpecInductionRecordId(reqDto.getCreateInductionId());
         domain.setSpecAppId(reqDto.getAppId());
         CommonFunctionHelper.setBaseInfoToLocal(domain);
         return new RefreshPublicFieldCacheRespDto();
      }
/**
      * code:dataToObject
      * name:M执行图片数据集转单条
      * desc:undefined
      * gen by moon at 9/6/2022, 10:10:22 PM
      * 
      **/
     @Trace(operationName = "M执行图片数据集转单条")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementPicDataSetSingleEntryRespDto implementPicDataSetSingleEntry(ImplementPicDataSetSingleEntryReqDto reqDto) {
         ImplementPicDataSetSingleEntryRespDto retData = new ImplementPicDataSetSingleEntryRespDto();
         if(reqDto.getPicDataSetSingleEntryList()==null || reqDto.getPicDataSetSingleEntryList().size()==0){
             return retData;
         }
         String str = "";
         for(String one : reqDto.getPicDataSetSingleEntryList()){
             str = one + "," + str;
         }
         retData.setDatasetField(str);
         String tmpStr = retData.getDatasetField().substring(0,retData.getDatasetField().length()-1);
         retData.setDatasetField(tmpStr);
        return retData;
      }
/**
      * code:specialMethodOutputPara
      * name:是否可以编辑
      * desc:undefined
      * gen by moon at 9/20/2022, 10:57:45 PM
      *
      **/
     @Trace(operationName = "是否可以编辑")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementOutputParametersRespDto implementOutputParameters(ImplementOutputParametersReqDto reqDto) {
        return BeanUtil.toBean(reqDto,ImplementOutputParametersRespDto.class);
      }
/**
      * code:specialMethodOutputPara
      * name:第一行（进度值）是否显示
      * desc:undefined
      * gen by moon at 9/20/2022, 10:57:45 PM
      *
      **/
     @Trace(operationName = "第一行（进度值）是否显示")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public AddOutputParametersRespDto addOutputParameters(AddOutputParametersReqDto reqDto) {
        return BeanUtil.toBean(reqDto,AddOutputParametersRespDto.class);
      }
/**
      * code:publicFieldCache
      * name:M3执行业务应用公共字段推送内存（特殊方法）
      * desc:undefined
      * gen by moon at 9/22/2022, 12:01:05 AM
      *
      **/
     @Trace(operationName = "M3执行业务应用公共字段推送内存（特殊方法）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementBizPublicFieldPushMemoryRespDto implementBizPublicFieldPushMemory(ImplementBizPublicFieldPushMemoryReqDto reqDto) {
         BaseInfoDO domain = new BaseInfoDO();
         if(BaseInfoHolder.contextHolder.get()!=null){
             BeanUtil.copyProperties(BaseInfoHolder.contextHolder.get().getBaseInfo(),domain);
             BaseInfoHolder.contextHolder.remove();
         }
         if(reqDto.getSpaceId()!=null){
             domain.setSpecSpaceId(reqDto.getSpaceId());
         }

         if(reqDto.getCreateInductionId()!=null){
             domain.setSpecInductionRecordId(reqDto.getCreateInductionId());
         }

         if(reqDto.getAppId()!=null){
             domain.setSpecAppId(reqDto.getAppId());
         }

         if(reqDto.getHighestOrgID()!=null){
             domain.setSpecHighestOrgID(reqDto.getHighestOrgID());
         }

         if(reqDto.getUserId()!=null){
             domain.setSpecUserId(reqDto.getUserId());
         }

         if(reqDto.getOriginalRoleMemberId()!=null){
             domain.setSpecOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());
         }

         CommonFunctionHelper.setBaseInfoToLocal(domain);
         return new ImplementBizPublicFieldPushMemoryRespDto();
      }
/**
      * code:publicFieldCache
      * name:M3执行业务应用业务字段推送内存（特殊方法）
      * desc:undefined
      * gen by moon at 9/22/2022, 12:03:28 AM
      *
      **/
     @Trace(operationName = "M3执行业务应用业务字段推送内存（特殊方法）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementBizBusinessFieldPushMemoryRespDto implementBizBusinessFieldPushMemory(ImplementBizBusinessFieldPushMemoryReqDto reqDto) {
       // TODO ruizhe skai dong ; 9/22/2022, 12:03:28 AM
         //应用字段推缓存
        return new ImplementBizBusinessFieldPushMemoryRespDto();
      }
/**
      * code:receptionService
      * name:M3执行业务应用构造出入参字段（特殊方法）
      * desc:undefined
      * gen by moon at 12/9/2022, 1:46:00 PM
      *
      **/
     @Trace(operationName = "M3执行业务应用构造出入参字段（特殊方法）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementBizConstructAccessParameterFieldRespDto implementBizConstructAccessParameterField(ImplementBizConstructAccessParameterFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto,ImplementBizConstructAccessParameterFieldRespDto.class);
      }
/**
      * code:receptionService
      * name:M3获取接收外部字段(特殊方法）
      * desc:undefined
      * gen by moon at 12/16/2022, 5:54:03 PM
      *
      **/
     @Trace(operationName = "M3获取接收外部字段(特殊方法）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ObtainReceiveOutFieldRespDto obtainReceiveOutField(ObtainReceiveOutFieldReqDto reqDto) {
        return BeanUtil.toBean(reqDto,ObtainReceiveOutFieldRespDto.class);
      }
/**
      * code:collectionsIntersectionsData
      * name:当前评价人可参与评价的角色列表
      * desc:undefined
      * gen by moon at 12/18/2022, 4:10:14 PM
      *
      **/
     @Trace(operationName = "当前评价人可参与评价的角色列表")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ObtainCollectionsIntersectionsDataRespDto obtainCollectionsIntersectionsData(ObtainCollectionsIntersectionsDataReqDto reqDto) {
         ObtainCollectionsIntersectionsDataRespDto retData = new ObtainCollectionsIntersectionsDataRespDto();
         for(String one : reqDto.getCollectionsIntersectionsDataAList()){
             if(reqDto.getCollectionsIntersectionsDataBList().contains(one)){
                 retData.getCollectionsIntersectionsDataList().add(one);
             }
         }
        return retData;
      }
/**
      * code:receptionService
      * name:M3约定是否向上计算为“1”
      * desc:undefined
      * gen by moon at 2/16/2023, 10:08:09 PM
      *
      **/
     @Trace(operationName = "M3约定是否向上计算为“1”")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementAccessParameterBizFieldRespDto implementAccessParameterBizField(ImplementAccessParameterBizFieldReqDto reqDto) {
         return BeanUtil.toBean(reqDto,ImplementAccessParameterBizFieldRespDto.class);
      }
/**
      * code:receptionService
      * name:M3约定审核权限为“1”
      * desc:undefined
      * gen by moon at 3/23/2023, 5:05:17 PM
      * 
      **/
     @Trace(operationName = "M3约定审核权限为“1”")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementAcceptFieldRespDto implementAcceptField(ImplementAcceptFieldReqDto reqDto) {
         return BeanUtil.toBean(reqDto,ImplementAcceptFieldRespDto.class);
      }
/**
      * code:receptionService
      * name:约定：是
      * desc:undefined
      * gen by moon at 6/1/2023, 2:40:31 AM
      *
      **/
     @Trace(operationName = "约定：是")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public CalculateAcceptAboveFieldsRespDto calculateAcceptAboveFields(CalculateAcceptAboveFieldsReqDto reqDto) {
         return BeanUtil.toBean(reqDto,CalculateAcceptAboveFieldsRespDto.class);
      }
/**
      * code:receptionService
      * name:提示：请录入该目标的进度、实际值
      * desc:undefined
      * gen by moon at 10/4/2023, 12:35:41 AM
      *
      **/
     @Trace(operationName = "提示：请录入该目标的进度、实际值")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementAcceptFieldByStandardDataRespDto implementAcceptFieldByStandardData(ImplementAcceptFieldByStandardDataReqDto reqDto) {
         return BeanUtil.toBean(reqDto,ImplementAcceptFieldByStandardDataRespDto.class);

      }
/**
      * code:objectToData
      * name:M执行图片多条转数据集
      * desc:undefined
      * gen by moon at 10/22/2023, 4:00:59 PM
      *
      **/
     @Trace(operationName = "M执行图片多条转数据集")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementPicMultipleSetDataEntryRespDto implementPicMultipleSetDataEntry(ImplementPicMultipleSetDataEntryReqDto reqDto) {
         ImplementPicMultipleSetDataEntryRespDto retData = new ImplementPicMultipleSetDataEntryRespDto();
         if (reqDto.getPicMultipleSetDataEntryList() == null || reqDto.getPicMultipleSetDataEntryList().size() <= 0) {
             return retData;
         }
         for (PicMultipleSetDataEntryDto oneSrc : reqDto.getPicMultipleSetDataEntryList()) {
             if (oneSrc.getDatasetField() != null && !oneSrc.getDatasetField().isEmpty()) {
                 String[] fileListSplit = oneSrc.getDatasetField().split(",");
                 if (fileListSplit != null && fileListSplit.length > 0) {
                     for (String oneFile : fileListSplit) {
                         if(oneFile.equals("--")){
                             continue;
                         }
                         PicMultipleSetDataEntryDto elm = new PicMultipleSetDataEntryDto();
                         elm.setCycleStageDataId(oneSrc.getCycleStageDataId());
                         elm.setDatasetPrimarykey(CommonFunctionHelper.getFilePath(oneFile));
                         retData.getPicMultipleSetDataEntryList().add(elm);
                     }
                 }
             }
         }
         return retData;
      }
/**
      * code:obtainPageTotals
      * name:M3-执行获取分页总条数（特殊方法）
      * desc:undefined
      * gen by moon at 12/8/2023, 11:21:23 AM
      *
      **/
     @Trace(operationName = "M3-执行获取分页总条数（特殊方法）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementObtainPageTotalsRespDto implementObtainPageTotals(ImplementObtainPageTotalsReqDto reqDto) {
         ImplementObtainPageTotalsRespDto retData = new ImplementObtainPageTotalsRespDto();
         retData.setTotals(0L);
         Page<?> page =  CommonFunctionHelper.getBaseInfoFromLocal().getPageInfo();
         if(page!=null){
             retData.setTotals(page.getTotal());
         }
         return retData;
      }
/**
      * code:receptionService
      * name:M3约定为待汇报
      * desc:undefined
      * gen by moon at 12/28/2023, 7:14:58 PM
      *
      **/
     @Trace(operationName = "M3约定为待汇报")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementSendMsgReceiverAcceptFieldRespDto implementSendMsgReceiverAcceptField(ImplementSendMsgReceiverAcceptFieldReqDto reqDto) {
         return BeanUtil.toBean(reqDto,ImplementSendMsgReceiverAcceptFieldRespDto.class);
      }
/**
      * code:receptionService
      * name:M3执行第四接收字段（特殊方法）
      * desc:undefined
      * gen by moon at 1/1/2024, 9:16:00 PM
      *
      **/
     @Trace(operationName = "M3执行第四接收字段（特殊方法）")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementFourthReceivingFieldRespDto implementFourthReceivingField(ImplementFourthReceivingFieldReqDto reqDto) {
         return BeanUtil.toBean(reqDto,ImplementFourthReceivingFieldRespDto.class);
      }
/**
      * code:receptionService
      * name:出参：同级兄弟汇报任务完成情况
      * desc:undefined
      * gen by moon at 2/17/2024, 9:17:29 AM
      *
      **/
     @Trace(operationName = "出参：同级兄弟汇报任务完成情况")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementFiveReceivingFieldRespDto implementFiveReceivingField(ImplementFiveReceivingFieldReqDto reqDto) {
         return BeanUtil.toBean(reqDto,ImplementFiveReceivingFieldRespDto.class);
      }
/**
      * code:receptionService
      * name:M3约定数据对象批次标识
      * desc:undefined
      * gen by moon at 4/30/2024, 1:47:55 PM
      *
      **/
     @Trace(operationName = "M3约定数据对象批次标识")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementEightReceivingFieldRespDto implementEightReceivingField(ImplementEightReceivingFieldReqDto reqDto) {
         return BeanUtil.toBean(reqDto,ImplementEightReceivingFieldRespDto.class);
      }
/**
      * code:receptionService
      * name:M3-约定字段：是、否
      * desc:undefined
      * gen by moon at 6/21/2024, 3:43:54 PM
      *
      **/
     @Trace(operationName = "M3-约定字段：是、否")
     @Tags({@Tag(key = "参数",value = "arg[0]"),
     @Tag(key = "返回值",value = "returnedObj")})
      public ImplementElevenReceivingFieldRespDto implementElevenReceivingField(ImplementElevenReceivingFieldReqDto reqDto) {
         return BeanUtil.toBean(reqDto,ImplementElevenReceivingFieldRespDto.class);
      }
    //手工接入方法
}
